home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-13 / thesrc10.zip / COMM3.C < prev    next >
C/C++ Source or Header  |  1992-08-11  |  24KB  |  732 lines
  1. /***********************************************************************/
  2. /* COMM3.C - Commands K-O                                              */
  3. /* This file contains all commands that can be assigned to function    */
  4. /* keys or typed on the command line.                                  */
  5. /***********************************************************************/
  6. /*
  7.  * THE - The Hessling Editor. A text editor similar to VM/CMS xedit.
  8.  * Copyright (C) 1991,1992 Mark Hessling
  9.  *
  10.  * This program is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU General Public License as
  12.  * published by the Free Software Foundation; either version 2 of
  13.  * the License, or any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18.  * General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to:
  22.  *
  23.  *    The Free Software Foundation, Inc.
  24.  *    675 Mass Ave,
  25.  *    Cambridge, MA 02139 USA.
  26.  *
  27.  *
  28.  * If you make modifications to this software that you feel increases
  29.  * it usefulness for the rest of the community, please email the
  30.  * changes, enhancements, bug fixes as well as any and all ideas to me.
  31.  * This software is going to be maintained and enhanced as deemed
  32.  * necessary by the community.
  33.  *
  34.  * Mark Hessling                     email: M.Hessling@itc.gu.edu.au
  35.  * 36 David Road                     Phone: +61 7 849 7731
  36.  * Holland Park                      Fax:   +61 7 875 7877
  37.  * QLD 4121
  38.  * Australia
  39.  */
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42.  
  43. #include "the.h"
  44.  
  45. /*#define DEBUG 1*/
  46.  
  47. /*-------------------------- external data ----------------------------*/
  48. extern LINE *next_line,*curr_line;
  49. extern VIEW_DETAILS *vd_current,*vd_first,*vd_mark;
  50. extern char current_screen;
  51. extern SCREEN_DETAILS screen[MAX_SCREENS];        /* screen structures */
  52. extern char display_screens;                      /* number of screens */
  53. extern char current_file;         /* pointer to current file */
  54. extern WINDOW *foot,*error_window;
  55. extern char error_on_screen;
  56. extern unsigned char *rec;
  57. extern unsigned short rec_len;
  58. extern unsigned char mode_insert;        /* defines insert mode toggle */
  59. extern unsigned char in_profile;    /* indicates if processing profile */
  60.  
  61. extern unsigned char temp_cmd[150];
  62. extern unsigned char *last_target;
  63. /*---------------------- function definitions -------------------------*/
  64. #ifdef PROTO
  65. void split_command(unsigned char *,unsigned char *,unsigned char *);
  66. int param_split(unsigned char *,unsigned char *[],int );
  67. long valid_target(unsigned char *);
  68. int get_row_for_focus_line(int,long,long);
  69. #else
  70. void split_command();
  71. int param_split();
  72. long valid_target();
  73. int get_row_for_focus_line();
  74. #endif
  75. /*man-start*********************************************************************
  76. COMMAND
  77.      left_arrow - move the cursor left one column
  78.  
  79. SYNTAX
  80.      ** effective only if bound to a key **
  81.  
  82. DESCRIPTION
  83.      The left_arrow command moves the cursor left one column in the
  84.      current window. Scrolling of the main window horizontally, occurs
  85.      if the cursor is at the left-most column and the left-most column
  86.      is not the first column of the line.
  87.  
  88. COMPATIBILITY
  89.      Compatible.
  90.  
  91. SEE ALSO
  92.      Right_arrow
  93.  
  94. STATUS
  95.      Complete.
  96. **man-end**********************************************************************/
  97. #ifdef PROTO
  98. int Left_arrow(unsigned char *params)
  99. #else
  100. int Left_arrow(params)
  101. unsigned char *params;
  102. #endif
  103. /***********************************************************************/
  104. {
  105. /*--------------------------- local data ------------------------------*/
  106.  unsigned short x,y;
  107.  short col,old_col;
  108. /*--------------------------- processing ------------------------------*/
  109. #ifdef TRACE
  110.  trace_function("comm3.c:   Left_arrow");
  111. #endif
  112.  getyx(CURRENT_WINDOW,y,x);
  113. /*---------------------------------------------------------------------*/
  114. /* For all windows, if we are not at left column, move 1 pos to left.  */
  115. /*---------------------------------------------------------------------*/
  116.  if (x > 0)
  117.    {
  118.     wmove(CURRENT_WINDOW,y,x-1);
  119. #ifdef TRACE
  120.     trace_return();
  121. #endif
  122.     return(OK);
  123.    }
  124. /*---------------------------------------------------------------------*/
  125. /* For MAIN windows  if we are at left column, shift to left  half the */
  126. /* width of the main window or util column 0 is the left-most column.  */
  127. /*---------------------------------------------------------------------*/
  128.  if (CURRENT_VIEW->current_window == WINDOW_MAIN)
  129.     if (x == 0 && CURRENT_VIEW->verify_start != CURRENT_VIEW->verify_col)
  130.       {
  131.        old_col = (CURRENT_VIEW->verify_col-1);
  132.        x = CURRENT_SCREEN.cols / 2;
  133.        col = max((short)CURRENT_VIEW->verify_start,
  134.                  (short)(CURRENT_VIEW->verify_col-1) - (short)x);
  135.        CURRENT_VIEW->verify_col = col;
  136.        show_page();
  137.        x = old_col - (CURRENT_VIEW->verify_col-1);
  138.        wmove(CURRENT_WINDOW,y,x-1);
  139.       }
  140. #ifdef TRACE
  141.  trace_return();
  142. #endif
  143.  return(OK);
  144. }
  145. /*man-start*********************************************************************
  146. COMMAND
  147.      locate - find the next/prev occurrence of a string
  148.  
  149. SYNTAX
  150.      [Locate] [string target]
  151.  
  152. DESCRIPTION
  153.      The LOCATE command looks for the next or previous occurrence of the
  154.      specified string target.  If no parameter is supplied, LOCATE
  155.      searches for the string that was used as the last string target, if
  156.      such a string exists.
  157.  
  158. COMPATIBILITY
  159.      Compatible.
  160.      Does not support not,and,or combinations of string targets.
  161.      ie ~,& and | not supported.
  162.  
  163. STATUS
  164.      Complete.
  165. **man-end**********************************************************************/
  166. #ifdef PROTO
  167. int Locate(unsigned char *params)
  168. #else
  169. int Locate(params)
  170. unsigned char *params;
  171. #endif
  172. /***********************************************************************/
  173. {
  174. /*--------------------------- local data ------------------------------*/
  175.  unsigned short x,y;
  176.  short rc;
  177. /*--------------------------- processing ------------------------------*/
  178. #ifdef TRACE
  179.  trace_function("comm3.c:   Locate");
  180. #endif
  181. /*---------------------------------------------------------------------*/
  182. /* If no parameter is specified, use the last_target. If that doesn't  */
  183. /* exist, error.                                                       */
  184. /*---------------------------------------------------------------------*/
  185.  if (strcmp(params,"") == 0)
  186.    {
  187.     if (strcmp(last_target,"") == 0)
  188.       {
  189.        display_error(39,"");
  190. #ifdef TRACE
  191.        trace_return();
  192. #endif
  193.        return(OK);
  194.       }
  195.     rc = command_line(last_target);
  196. #ifdef TRACE
  197.     trace_return();
  198. #endif
  199.     return(rc);
  200.    }
  201.  rc = command_line(params);
  202. #ifdef TRACE
  203.  trace_return();
  204. #endif
  205.  return(rc);
  206. }
  207. /*man-start*********************************************************************
  208. COMMAND
  209.      mark - mark a portion of text
  210.  
  211. SYNTAX
  212.      MARK Line|Box|Stream
  213.  
  214. DESCRIPTION
  215.      The MARK command marks a portion of text for later processing
  216.      usually by a COPY or MOVE command.
  217.  
  218. COMPATIBILITY
  219.      Does not implement Box or Stream...yet.
  220.  
  221. STATUS
  222.      Complete...LINE option is anyway.
  223. **man-end**********************************************************************/
  224. #ifdef PROTO
  225. int Mark(unsigned char *params)
  226. #else
  227. int Mark(params)
  228. unsigned char *params;
  229. #endif
  230. /***********************************************************************/
  231. {
  232. /*--------------------------- local data ------------------------------*/
  233.  register int i;
  234.  long true_line;
  235.  unsigned short y,x;
  236. /*--------------------------- processing ------------------------------*/
  237. #ifdef TRACE
  238.  trace_function("comm3.c:   Mark");
  239. #endif
  240.  if (strcmp(params,"line") != 0)
  241.    {
  242.     display_error(1,params);
  243. #ifdef TRACE
  244.     trace_return();
  245. #endif
  246.     return(OK);
  247.    }
  248.  if (CURRENT_VIEW->current_window == WINDOW_COMMAND)
  249.     true_line = CURRENT_VIEW->current_line;
  250.  else
  251.     true_line = CURRENT_VIEW->focus_line;
  252. /*---------------------------------------------------------------------*/
  253. /* If we are on 'Top of File' or 'Bottom of File' lines, error.        */
  254. /*---------------------------------------------------------------------*/
  255.  if (true_line == 0L || true_line == CURRENT_FILE->number_lines+1)
  256.    {
  257.     display_error(38,"");
  258. #ifdef TRACE
  259.     trace_return();
  260. #endif
  261.     return(OK);
  262.    }
  263.  MARK_VIEW = CURRENT_VIEW;
  264. /*---------------------------------------------------------------------*/
  265. /* Set the new values for top and bottom lines marked.                 */
  266. /*---------------------------------------------------------------------*/
  267.  if (CURRENT_VIEW->mark_start_line == (-1L)
  268.  &&  CURRENT_VIEW->mark_end_line == (-1L))
  269.     CURRENT_VIEW->mark_start_line = CURRENT_VIEW->mark_end_line = true_line;
  270.  else
  271.    {
  272.     if (true_line > CURRENT_VIEW->mark_end_line)
  273.        CURRENT_VIEW->mark_end_line = true_line;
  274.     if (true_line < CURRENT_VIEW->mark_start_line)
  275.        CURRENT_VIEW->mark_start_line = true_line;
  276.     if (true_line < CURRENT_VIEW->mark_end_line
  277.     &&  true_line > CURRENT_VIEW->mark_start_line)
  278.       {
  279.        if (true_line-CURRENT_VIEW->mark_end_line >
  280.            CURRENT_VIEW->mark_start_line-true_line)
  281.           CURRENT_VIEW->mark_end_line = true_line;
  282.        else
  283.           CURRENT_VIEW->mark_start_line = true_line;
  284.        show_page();
  285.       }
  286.    }
  287. /*---------------------------------------------------------------------*/
  288. /* Now it is time to display the highlighted line(s).                  */
  289. /*---------------------------------------------------------------------*/
  290.  getyx(CURRENT_WINDOW,y,x);
  291.  show_highlighted_lines();
  292. /*---------------------------------------------------------------------*/
  293. /* If the current line is inside the marked block, highlight it.       */
  294. /*---------------------------------------------------------------------*/
  295.  if (CURRENT_VIEW->current_line >= CURRENT_VIEW->mark_start_line
  296.  &&  CURRENT_VIEW->current_line <= CURRENT_VIEW->mark_end_line)
  297.      highlight_line(CURRENT_VIEW->current_row,colour[ATTR_CBLOCK]);
  298.  wmove(CURRENT_WINDOW,y,x);
  299. #ifdef TRACE
  300.  trace_return();
  301. #endif
  302.  return(OK);
  303. }
  304. /*man-start*********************************************************************
  305. COMMAND
  306.      move - move a portion of text
  307.  
  308. SYNTAX
  309.      MOVE BLOCK
  310.  
  311. DESCRIPTION
  312.      The MARK command marks a portion of text for later processing
  313.      usually by a COPY or MOVE command.
  314.  
  315. COMPATIBILITY
  316.      Does not implement Box or Stream...yet.
  317.  
  318. STATUS
  319.      Bug with positioning of cursor when moving text from one view to
  320.      another. The cursor is left where it was when in that view. If the
  321.      delete of lines causes the bottom of the file to be positioned
  322.      above the focus line, the cursor will appear in no-man's land.
  323.      Use refresh to correct display.
  324. **man-end**********************************************************************/
  325. #ifdef PROTO
  326. int Move(unsigned char *params)
  327. #else
  328. int Move(params)
  329. unsigned char *params;
  330. #endif
  331. /***********************************************************************/
  332. {
  333. /*--------------------------- local data ------------------------------*/
  334. #define MOVE_PARAMS  1
  335.  unsigned char *word[MOVE_PARAMS+1];
  336.  unsigned short num_params;
  337.  long num_lines;
  338.  LINE *curr,*old_curr,*save_old_curr;
  339.  register int i;
  340.  unsigned short y,x;
  341.  bool same_file;
  342.  unsigned long li;
  343. /*--------------------------- processing ------------------------------*/
  344. #ifdef TRACE
  345.  trace_function("comm3.c:   Move");
  346. #endif
  347.  num_params = param_split(params,word,MOVE_PARAMS);
  348.  if (strcmp(word[0],"block") != 0)
  349.    {
  350.     display_error(1,word[0]);
  351. #ifdef TRACE
  352.     trace_return();
  353. #endif
  354.     return(OK);
  355.    }
  356. /*---------------------------------------------------------------------*/
  357. /* If on the command line, error.                                      */
  358. /*---------------------------------------------------------------------*/
  359.  if (CURRENT_VIEW->current_window == WINDOW_COMMAND)
  360.    {
  361.     display_error(38,"");
  362. #ifdef TRACE
  363.     trace_return();
  364. #endif
  365.     return(OK);
  366.    }
  367. /*---------------------------------------------------------------------*/
  368. /* If no marked block in any view, return error.                       */
  369. /*---------------------------------------------------------------------*/
  370.  if (MARK_VIEW == (VIEW_DETAILS *)NULL)
  371.    {
  372.     display_error(44,"");
  373. #ifdef TRACE
  374.     trace_return();
  375. #endif
  376.     return(OK);
  377.    }
  378.  post_process_line(CURRENT_VIEW->focus_line);
  379. /*---------------------------------------------------------------------*/
  380. /* Determine the number of lines in the marked block (any view)        */
  381. /*---------------------------------------------------------------------*/
  382.  num_lines = MARK_VIEW->mark_end_line-MARK_VIEW->mark_start_line+1;
  383. /*---------------------------------------------------------------------*/
  384. /* Find the LINE pointer for start of marked block.                    */
  385. /*---------------------------------------------------------------------*/
  386.  old_curr = ll_find(MARK_FILE->first_line,MARK_VIEW->mark_start_line);
  387.  save_old_curr = old_curr;
  388. /*---------------------------------------------------------------------*/
  389. /* Find the LINE pointer for the current focus line.                   */
  390. /* If the focus line is the bottom of file line, subtract 1 from it.   */
  391. /*---------------------------------------------------------------------*/
  392.  if (CURRENT_VIEW->focus_line == CURRENT_FILE->number_lines+1)
  393.     li = 1L;
  394.  else
  395.     li = 0L;
  396.  curr = ll_find(CURRENT_FILE->first_line,CURRENT_VIEW->focus_line-li);
  397. /*---------------------------------------------------------------------*/
  398. /* Add each line from the marked view after the current focus line.    */
  399. /*---------------------------------------------------------------------*/
  400.  for (i=0;i<num_lines;i++)
  401.     {
  402.      if ((curr = add_line(CURRENT_FILE->first_line,curr,
  403.                           old_curr->line,old_curr->length)) == NULL)
  404.        {
  405.         display_error(30,"");
  406. #ifdef TRACE
  407.         trace_return();
  408. #endif
  409.         return(ERROR);
  410.        }
  411.      old_curr = old_curr->next;
  412.     }
  413. /*---------------------------------------------------------------------*/
  414. /* Increment the number of lines counter for the current file and the  */
  415. /* number of alterations.                                              */
  416. /*---------------------------------------------------------------------*/
  417.  increment_alt();
  418.  CURRENT_FILE->number_lines += num_lines;
  419. /*---------------------------------------------------------------------*/
  420. /* Delete from the linked list the number of lines specified in the    */
  421. /* direction specified for the marked file.                            */
  422. /*---------------------------------------------------------------------*/
  423.  for (i=0;i<num_lines;i++)
  424.      save_old_curr = ll_del(MARK_FILE->first_line,
  425.                             save_old_curr,DIRECTION_FORWARD);
  426. /*---------------------------------------------------------------------*/
  427. /* Decrement the number of lines counter for the marked  file and the  */
  428. /* number of alterations. Don't worry about testing for AUTOSAVE.      */
  429. /*---------------------------------------------------------------------*/
  430.  MARK_FILE->autosave_alt++;
  431.  MARK_FILE->save_alt++;
  432.  MARK_FILE->number_lines -= num_lines;
  433. /*---------------------------------------------------------------------*/
  434. /* Determine where the focus_line should end up. If the marked block is*/
  435. /* in the same view and is above the focus_line, change it.            */
  436. /*---------------------------------------------------------------------*/
  437.  if (MARK_VIEW == CURRENT_VIEW)
  438.    {
  439.     same_file = TRUE;
  440.     if (MARK_VIEW->mark_start_line < CURRENT_VIEW->focus_line)
  441.       {
  442.        CURRENT_VIEW->focus_line -= num_lines;
  443.        i = 0;
  444.       }
  445.     else
  446.        i = 1;
  447.    }
  448.  else
  449.    {
  450.     same_file = FALSE;
  451.     i = 1;
  452.    }
  453. /*---------------------------------------------------------------------*/
  454. /* Set the highlighting of lines up. The newly copied block remains    */
  455. /* marked in the current view and the previous marked block is reset.  */
  456. /*---------------------------------------------------------------------*/
  457.  MARK_VIEW->mark_start_line = MARK_VIEW->mark_end_line = (-1L);
  458.  CURRENT_VIEW->mark_start_line = CURRENT_VIEW->focus_line + 1L;
  459.  CURRENT_VIEW->mark_end_line = CURRENT_VIEW->focus_line + num_lines;
  460.  
  461.  CURRENT_VIEW->focus_line = CURRENT_VIEW->mark_start_line;
  462.  
  463. /*---------------------------------------------------------------------*/
  464. /* The following does a 'reset block' in the current view.             */
  465. /*---------------------------------------------------------------------*/
  466.  CURRENT_VIEW->mark_start_line = CURRENT_VIEW->mark_end_line = (-1L);
  467.  MARK_VIEW = (VIEW_DETAILS *)NULL;
  468.  
  469.  pre_process_line(CURRENT_VIEW->focus_line);
  470.  
  471.  getyx(CURRENT_WINDOW,y,x);
  472.  if (y == CURRENT_SCREEN.rows-1       /* on bottom line of window */
  473.  &&  !same_file)                    /* and different files */
  474.    {
  475.     CURRENT_VIEW->current_line = CURRENT_VIEW->focus_line;
  476.     y = CURRENT_VIEW->current_row;
  477.     i = 0;
  478.    }
  479.  else
  480.     y = get_row_for_focus_line(CURRENT_VIEW->current_row,
  481.                                CURRENT_VIEW->focus_line,
  482.                                CURRENT_VIEW->current_line);
  483.  show_page();
  484.  wmove(CURRENT_WINDOW,y,x);
  485.  
  486. #ifdef TRACE
  487.  trace_return();
  488. #endif
  489.  return(OK);
  490. }
  491. /*man-start*********************************************************************
  492. COMMAND
  493.      next - move forward in the file a number of lines
  494.  
  495. SYNTAX
  496.      Next [target]
  497.  
  498. DESCRIPTION
  499.      The NEXT command moves the current_line forwards the number of
  500.      lines specified by the target. Negative targets move backwards
  501.      through the file.
  502.  
  503. COMPATIBILITY
  504.      Compatible.
  505.  
  506. SEE ALSO
  507.      Up
  508.  
  509. STATUS
  510.      Complete.
  511. **man-end**********************************************************************/
  512. #ifdef PROTO
  513. int Next(unsigned char *params)
  514. #else
  515. int Next(params)
  516. unsigned char *params;
  517. #endif
  518. /***********************************************************************/
  519. {
  520. /*--------------------------- local data ------------------------------*/
  521. #define NEX_PARAMS  1
  522.  unsigned char *word[NEX_PARAMS+1];
  523.  unsigned short num_params;
  524.  long num_lines;
  525.  unsigned short y,x;
  526. /*--------------------------- processing ------------------------------*/
  527. #ifdef TRACE
  528.  trace_function("comm3.c:   Next");
  529. #endif
  530.  num_params = param_split(params,word,NEX_PARAMS);
  531.  if (num_params == 0)
  532.    {
  533.     num_params = 1;
  534.     word[0] = (unsigned char *)"1";
  535.    }
  536.  if (num_params != 1)
  537.    {
  538.     display_error(1,word[1]);
  539. #ifdef TRACE
  540.     trace_return();
  541. #endif
  542.     return(ERROR);
  543.    }
  544.  if ((num_lines = valid_target(word[0])) == TARGET_ERROR)
  545.    {
  546.     display_error(4,word[0]);
  547. #ifdef TRACE
  548.     trace_return();
  549. #endif
  550.     return(ERROR);
  551.    }
  552.  post_process_line(CURRENT_VIEW->focus_line);
  553.  if (in_profile || CURRENT_VIEW->current_window == WINDOW_COMMAND)
  554.    {
  555.     CURRENT_VIEW->current_line += num_lines;
  556.     CURRENT_VIEW->focus_line = CURRENT_VIEW->current_line;
  557.     pre_process_line(CURRENT_VIEW->focus_line);
  558.     if (!in_profile)
  559.        show_page();
  560.    }
  561.  else
  562.    {
  563.     getyx(CURRENT_WINDOW,y,x);
  564.     CURRENT_VIEW->focus_line += num_lines;
  565.     pre_process_line(CURRENT_VIEW->focus_line);
  566.     if (num_lines + y <= 0
  567.     ||  num_lines + y >= CURRENT_SCREEN.rows)
  568.       {
  569.        CURRENT_VIEW->current_line = CURRENT_VIEW->focus_line;
  570.        y = CURRENT_VIEW->current_row;
  571.       }
  572.     else
  573.        y = get_row_for_focus_line(CURRENT_VIEW->current_row,
  574.                                CURRENT_VIEW->focus_line,
  575.                                CURRENT_VIEW->current_line);
  576.     show_page();
  577.     wmove(CURRENT_WINDOW,y,x);
  578.    }
  579. #ifdef TRACE
  580.  trace_return();
  581. #endif
  582.  return(OK);
  583. }
  584. /*man-start*********************************************************************
  585. COMMAND
  586.      nextwindow - switch focus of editting session to other window
  587.  
  588. SYNTAX
  589.      NEXTWindow
  590.  
  591. DESCRIPTION
  592.      The NEXTWINDOW command moves the focus of the editting session to
  593.      the other window (if more than one window is currently displayed)
  594.      or to the next file in the ring.
  595.  
  596. COMPATIBILITY
  597.      Compatible.
  598.  
  599. SEE ALSO
  600.      Edit,Screen
  601.  
  602. STATUS
  603.      Complete.
  604. **man-end**********************************************************************/
  605. #ifdef PROTO
  606. int Nextwindow(unsigned char *params)
  607. #else
  608. int Nextwindow(params)
  609. unsigned char *params;
  610. #endif
  611. /***********************************************************************/
  612. {
  613. /*--------------------------- local data ------------------------------*/
  614.  short rc;
  615. /*--------------------------- processing ------------------------------*/
  616. #ifdef TRACE
  617.  trace_function("comm3.c:   Nextwindow");
  618. #endif
  619.  if (strcmp(params,"") != 0)
  620.    {
  621.     display_error(1,params);
  622. #ifdef TRACE
  623.     trace_return();
  624. #endif
  625.     return(OK);
  626.    }
  627.  if (display_screens == 1)
  628.    {
  629.     rc = Edit("");
  630. #ifdef TRACE
  631.     trace_return();
  632. #endif
  633.     return(rc);
  634.    }
  635.  post_process_line(CURRENT_VIEW->focus_line);
  636.  current_screen = (current_screen == 0) ? 1 : 0;
  637.  CURRENT_VIEW = CURRENT_SCREEN.screen_view;
  638.  pre_process_line(CURRENT_VIEW->focus_line);
  639. #ifdef TRACE
  640.  trace_return();
  641. #endif
  642.  return(OK);
  643. }
  644. /*man-start*********************************************************************
  645. COMMAND
  646.      os_cmd - execute an operating system command
  647.  
  648. SYNTAX
  649.      !|dos [command]
  650.  
  651. DESCRIPTION
  652.      The OS_CMD command executes the supplied os command.
  653.  
  654.      This command is not called directly but is called with the ! or
  655.      dos commands.
  656.  
  657. COMPATIBILITY
  658.      Compatible.
  659.  
  660. STATUS
  661.      Complete.
  662. **man-end**********************************************************************/
  663. #ifdef PROTO
  664. int Os_cmd(unsigned char *params)
  665. #else
  666. int Os_cmd(params)
  667. unsigned char *params;
  668. #endif
  669. /***********************************************************************/
  670. {
  671. #if defined(DOS) || defined(OS2)
  672. #define SHELL "COMSPEC"
  673. #else
  674. #define SHELL "SHELL"
  675. #endif
  676. /*--------------------------- local data ------------------------------*/
  677. #define OS_PARAMS  1
  678.  unsigned char *word[OS_PARAMS+1];
  679.  char parm[OS_PARAMS];
  680.  register int i;
  681.  unsigned short num_params;
  682.  int rc;
  683. /*--------------------------- processing ------------------------------*/
  684. #ifdef TRACE
  685.  trace_function("comm3.c:   Os_cmd");
  686. #endif
  687.  touchwin(stdscr);
  688.  wmove(stdscr,0,0);
  689.  wrefresh(stdscr);   /* clear screen */
  690. /* really should get COMSPEC (DOS) or SHELL (UNIX) and run that */
  691. #ifdef UNIX
  692.  reset_shell_mode();
  693. #endif
  694.  if (strcmp(params,"") == 0)
  695.     strcpy(temp_cmd,getenv(SHELL));
  696.  else
  697.     strcpy(temp_cmd,params);
  698.  system(temp_cmd);
  699.  printf("\n\nHit any key to continue...");
  700.  fflush(stdout);
  701. #ifdef UNIX
  702.  reset_prog_mode();
  703. #endif
  704.  
  705.  wgetch(stdscr);
  706.  wrefresh(curscr);   /* clear screen */
  707.  
  708.  touchwin(foot);
  709.  wnoutrefresh(foot);
  710.  touchwin(CURRENT_WINDOW_IDLINE);
  711.  wnoutrefresh(CURRENT_WINDOW_IDLINE);
  712.  touchwin(CURRENT_WINDOW_MAIN);
  713.  wnoutrefresh(CURRENT_WINDOW_MAIN);
  714.  touchwin(CURRENT_WINDOW_ARROW);
  715.  wnoutrefresh(CURRENT_WINDOW_ARROW);
  716.  if (CURRENT_VIEW->prefix_on)
  717.    {
  718.     touchwin(CURRENT_WINDOW_PREFIX);
  719.     wnoutrefresh(CURRENT_WINDOW_PREFIX);
  720.    }
  721.  touchwin(CURRENT_WINDOW_COMMAND);
  722.  wnoutrefresh(CURRENT_WINDOW_COMMAND);
  723.  doupdate();
  724. #if defined(DOS) || defined(OS2)
  725.  draw_cursor();
  726. #endif
  727. #ifdef TRACE
  728.  trace_return();
  729. #endif
  730.  return(OK);
  731. }
  732.